package models

import (
	"database/sql"
	"encoding/json"
	"log"
)

import (
	_ "github.com/go-sql-driver/mysql"
)

func init() {
	//init
}

//根据楼幢楼层的ID号，从数据库取得房间的列表
func Get_lyfjs(xm_id int, parent_id int) (rets []Sut_lyfj) {
	//返回树型菜单，类型为树型结构体
	var (
		sqlstr string
		rows   *sql.Rows
		err    error
	)
	if db.Ping() != nil {
		log.Panicln("数据库已断开连接！")
	}
	sqlstr = "SELECT lyfj_id, ParentId, lyfj_name,type_id,COALESCE(remark,''),COALESCE(sort,0) FROM t1_xm_lyfj where xm_id=? and parentid=? ORDER BY sort ASC"
	//log.Println("test.go Get_tests，SQL字符串：", sqlstr)
	rows, err = db.Query(sqlstr, xm_id, parent_id)
	defer rows.Close()
	if err != nil {
		log.Println(err.Error())
		return
	}
	var tmp Sut_lyfj
	for rows.Next() { //开始循环读取字段
		err = rows.Scan(&tmp.Id, &tmp.Pid, &tmp.Name, &tmp.Type_id, &tmp.Remark, &tmp.Sort) //数据指针，会把得到的数据，往刚才id 和 lvs引入
		if err != nil {
			log.Println("menu.go 取记录出错！")
		}
		//log.Println("menu.go Id:", tmp.Id, " Pid:", tmp.Pid, " Name:", tmp.Name, " Url:", tmp.Remark)
		rets = append(rets, tmp) //将记录保存到切片
	}
	return rets
}

//根据项目ID号和父级id号（楼层ID号），取得楼幢、楼层，返回的是数组列表
func Get_lyfj_list(xm_id int, type_id int) (datas []Sut_lyfj) {
	var (
		sqlstr string
		err    error
		rows   *sql.Rows
		tmp    Sut_lyfj
	)
	//xm_id = 1	//1是华师运维的项目ID
	//通过项目ID，取得此项目的楼宇房间列表切片字段
	sqlstr = "select lyfj_id, ParentId, lyfj_name,type_id,COALESCE(remark,''),COALESCE(sort,0) from t1_xm_lyfj where xm_id=? and type_id<? ORDER BY sort ASC"
	//当字段有空数据NULL时，go的rows.scan会报错，所以要添加mysql函数COALESCE()，有空数据时给一个默认数据
	rows, err = db.Query(sqlstr, xm_id, type_id)
	defer rows.Close()
	//log.Println(sqlstr)
	//判断err是否有错误的数据，有err数据就显示panic的数据
	if err != nil {
		//panic(err.Error())
		log.Println(err.Error())
		return
	}
	for rows.Next() { //开始循环
		err = rows.Scan(&tmp.Id, &tmp.Pid, &tmp.Name, &tmp.Type_id, &tmp.Remark, &tmp.Sort) //数据指针，会把得到的数据，往刚才id 和 lvs引入
		if err != nil {
			//log.Println("Get_lyfj_list( parentid是", tmp.Pid, "\t lyfj_id号是", strconv.Itoa(tmp.Id)+"\t lvs是", tmp.Name) //输出来而已，看看
			log.Println("从ROWS读取数据时出错！err:", err)
		}
		datas = append(datas, tmp)
	}
	return datas
}

/*最多取到5层数据，学校-校区-楼幢-楼层-教室，返回根据结构树型的JSON数据,type_id为5则表示所有楼层，为6则表示所有楼层及房间*/
func Get_lyfj_json(xm_id int, type_id int) (json_data []byte) {
	var (
		data  Sut_lyfj
		datas []Sut_lyfj
		err   error
	)
	datas = Get_lyfj_list(xm_id, type_id)
	for _, v := range datas {
		if v.Pid == 0 {
			data = v
		}
	}
	/*第1次循环遍历，第0层根节点取到第一层节点*/

	for _, v := range datas {
		if v.Pid == data.Id {
			//v.Name = v.Name + "<span class='text-right'>&nbsp;&nbsp;&nbsp;<button id='btn_treeview_refresh' class='btn btn-default' onclick='exxecutefunction()'><span class='glyphicon glyphicon-plus' aira-hidden='true'></span>新增</button>"
			//v.Name = v.Name + "&nbsp;<button id='btn_treeview_refresh' class='btn btn-default' onclick='exxecutefunction()'><span class='glyphicon glyphicon-edit' aira-hidden='true'></span>编辑</button></span>"
			data.Child = append(data.Child, &Sut_lyfj{v.Id, v.Pid, v.Name, v.Type_id, v.Remark, v.Sort, v.Child})
		}
	}
	log.Printf("第1次循环遍历，第0层根节点取到第一层节点%s\n", json_data)

	/*循环遍历第一层节点，取得第一层节点的元素，即取到了第二层元素*/
	for k1, v1 := range data.Child {
		/*遍历MAP，取得第一层节点的子节点*/
		for _, v2 := range datas {
			if v2.Pid == v1.Id {
				data.Child[k1].Child = append(data.Child[k1].Child, &Sut_lyfj{v2.Id, v2.Pid, v2.Name, v2.Type_id, v2.Remark, v2.Sort, v2.Child})
				/*下面的语句与上面的语句执行后一样能取得Child，能够表示出切片是引用类型，即v1=data.Child[k].Child
				v1.Child = append(v1.Child, &LYFJ{v2.Id, v2.Parentid, v2.Name, v2.Child})
				*/
			}
		}
	}
	log.Printf("第2次循环遍历，根节点取到第二层节点%s\n", json_data)
	/*循环遍历第二层节点，取得第二层节点的元素，即取到了第三层元素*/

	for k1, _ := range data.Child {
		for k2, v2 := range data.Child[k1].Child {
			/*遍历MAP，取得第三层元素*/
			for _, v3 := range datas {
				if v3.Pid == v2.Id {
					data.Child[k1].Child[k2].Child = append(data.Child[k1].Child[k2].Child, &Sut_lyfj{v3.Id, v3.Pid, v3.Name, v3.Type_id, v3.Remark, v3.Sort, v3.Child})
				}
			}
		}
	}
	log.Printf("第3次循环遍历，根节点取到第三层节点%s\n", json_data)
	/*循环遍历第三层节点，取得第三层节点的元素，即取到了第四层元素*/
	for _, v1 := range data.Child {
		for _, v2 := range v1.Child {
			for _, v3 := range v2.Child {
				/*遍历MAP，取得第四层元素*/
				for _, v4 := range datas {
					if v4.Pid == v3.Id {
						v3.Child = append(v3.Child, &Sut_lyfj{v4.Id, v4.Pid, v4.Name, v4.Type_id, v4.Remark, v4.Sort, v4.Child})
					}
				}
			}
		}
	}
	log.Printf("第4次循环遍历，根节点取到第四层节点%s\n", json_data)
	json_data, err = json.MarshalIndent(data, "", "  ") //json.Marshal(data)
	if err != nil {
		log.Panicf("JSON marshaling failed: %s", err)
	}
	//log.Printf("%s\n", json_data)
	return json_data
}

type Sut_fj struct {
	Id   int
	Name string
}

//验证房间是否存在，用于前台页面验证插件，返回布尔型
////房间验证的API，用于POST,beego.Router("/api/v1/fjValidator", &controllers.Api_fjController{})
func (this *Sut_fj) Validator_fj_name() bool {
	var (
		sqlstr   string
		id_count int
		err      error
	)
	sqlstr = "select count(lyfj_id) from t1_xm_lyfj where lyfj_name = ?"
	err = db.QueryRow(sqlstr, this.Name).Scan(&id_count)
	if err != nil {
		return false
	}
	if id_count >= 1 {
		return true
	} else {
		return false
	}
}
